local ____lualib = base.tsc
local __TS__New = ____lualib.__TS__New
local __TS__Keyword = ____lualib.__TS__Keyword
local __TS__ArrayForEachEx = ____lualib.__TS__ArrayForEachEx
local Map = ____lualib.Map
local __TS__TypeReference = ____lualib.__TS__TypeReference
local __TS__Class = ____lualib.__TS__Class
local __TS__ClassExtends = ____lualib.__TS__ClassExtends
local __TS__SuperTypeArgumentsFuncWrapper = ____lualib.__TS__SuperTypeArgumentsFuncWrapper
local __TS__ArrayFilter = ____lualib.__TS__ArrayFilter
local __TS__ObjectAssign = ____lualib.__TS__ObjectAssign
local __TS__Iterator = ____lualib.__TS__Iterator
local __TS__ArraySplice = ____lualib.__TS__ArraySplice
local __TS__Class2 = ____lualib.__TS__Class2
Cast = base.tsc.CLASSES.Cast or __TS__Class2("Cast")
RegionCircle = base.tsc.CLASSES.RegionCircle or __TS__Class2("RegionCircle")
RegionRect = base.tsc.CLASSES.RegionRect or __TS__Class2("RegionRect")
Vector = base.tsc.CLASSES.Vector or __TS__Class2("Vector")
ScoreCropData = base.tsc.CLASSES.ScoreCropData or __TS__Class2("ScoreCropData")
crop = base.tsc.CLASSES.crop or __TS__Class2("crop")
QuestCondition = base.tsc.CLASSES.QuestCondition or __TS__Class2("QuestCondition")
Quest = base.tsc.CLASSES.Quest or __TS__Class2("Quest")
SceneObject = base.tsc.CLASSES.SceneObject or __TS__Class2("SceneObject")
UnitPropertyBonus = base.tsc.CLASSES.UnitPropertyBonus or __TS__Class2("UnitPropertyBonus")
ScoreRankAddParam = base.tsc.CLASSES.ScoreRankAddParam or __TS__Class2("ScoreRankAddParam")
ScoreRankSetParam = base.tsc.CLASSES.ScoreRankSetParam or __TS__Class2("ScoreRankSetParam")
autotest_log = base.tsc.CLASSES.autotest_log or __TS__Class2("autotest_log")
UnitBuff = base.tsc.CLASSES.UnitBuff or __TS__Class2("UnitBuff")
DateTime = base.tsc.CLASSES.DateTime or __TS__Class2("DateTime")
os = base.tsc.CLASSES.os or __TS__Class2("os")
ScoreMoneyParam = base.tsc.CLASSES.ScoreMoneyParam or __TS__Class2("ScoreMoneyParam")
ScoreMsgID = base.tsc.CLASSES.ScoreMsgID or __TS__Class2("ScoreMsgID")
ScoreNameData = base.tsc.CLASSES.ScoreNameData or __TS__Class2("ScoreNameData")
ScoreID = base.tsc.CLASSES.ScoreID or __TS__Class2("ScoreID")
ScoreListID = base.tsc.CLASSES.ScoreListID or __TS__Class2("ScoreListID")
ScoreMsgData = base.tsc.CLASSES.ScoreMsgData or __TS__Class2("ScoreMsgData")
ScoreGetRankTotalParam = base.tsc.CLASSES.ScoreGetRankTotalParam or __TS__Class2("ScoreGetRankTotalParam")
ScoreGetRankTotalData = base.tsc.CLASSES.ScoreGetRankTotalData or __TS__Class2("ScoreGetRankTotalData")
ScoreGetUserRankData = base.tsc.CLASSES.ScoreGetUserRankData or __TS__Class2("ScoreGetUserRankData")
ScoreGetRankListData = base.tsc.CLASSES.ScoreGetRankListData or __TS__Class2("ScoreGetRankListData")
ScoreGetUserRankParam = base.tsc.CLASSES.ScoreGetUserRankParam or __TS__Class2("ScoreGetUserRankParam")
ScoreGetRankListParam = base.tsc.CLASSES.ScoreGetRankListParam or __TS__Class2("ScoreGetRankListParam")
ScoreChannelMsgData = base.tsc.CLASSES.ScoreChannelMsgData or __TS__Class2("ScoreChannelMsgData")
ScoreNameSearchParam = base.tsc.CLASSES.ScoreNameSearchParam or __TS__Class2("ScoreNameSearchParam")
ScoreNameNewParam = base.tsc.CLASSES.ScoreNameNewParam or __TS__Class2("ScoreNameNewParam")
ScoreMsgQueryParam = base.tsc.CLASSES.ScoreMsgQueryParam or __TS__Class2("ScoreMsgQueryParam")
ScoreMsgSendParam = base.tsc.CLASSES.ScoreMsgSendParam or __TS__Class2("ScoreMsgSendParam")
ScoreListData = base.tsc.CLASSES.ScoreListData or __TS__Class2("ScoreListData")
ScoreListDeleteParam = base.tsc.CLASSES.ScoreListDeleteParam or __TS__Class2("ScoreListDeleteParam")
ScoreListModifyParam = base.tsc.CLASSES.ScoreListModifyParam or __TS__Class2("ScoreListModifyParam")
ScoreListAddParam = base.tsc.CLASSES.ScoreListAddParam or __TS__Class2("ScoreListAddParam")
ScoreMoneyData = base.tsc.CLASSES.ScoreMoneyData or __TS__Class2("ScoreMoneyData")
ScoreAddParam = base.tsc.CLASSES.ScoreAddParam or __TS__Class2("ScoreAddParam")
ScoreSetParam = base.tsc.CLASSES.ScoreSetParam or __TS__Class2("ScoreSetParam")
ScoreData = base.tsc.CLASSES.ScoreData or __TS__Class2("ScoreData")
UserID = base.tsc.CLASSES.UserID or __TS__Class2("UserID")
ScoreGetParam = base.tsc.CLASSES.ScoreGetParam or __TS__Class2("ScoreGetParam")
ScoreObjData = base.tsc.CLASSES.ScoreObjData or __TS__Class2("ScoreObjData")
ScoreCommitter = base.tsc.CLASSES.ScoreCommitter or __TS__Class2("ScoreCommitter")
AISearcher = base.tsc.CLASSES.AISearcher or __TS__Class2("AISearcher")
DataCache = base.tsc.CLASSES.DataCache or __TS__Class2("DataCache")
Sight = base.tsc.CLASSES.Sight or __TS__Class2("Sight")
UnitGroup = base.tsc.CLASSES.UnitGroup or __TS__Class2("UnitGroup")
Line = base.tsc.CLASSES.Line or __TS__Class2("Line")
Trigger = base.tsc.CLASSES.Trigger or __TS__Class2("Trigger")
Player = base.tsc.CLASSES.Player or __TS__Class2("Player")
Inventory = base.tsc.CLASSES.Inventory or __TS__Class2("Inventory")
Skill = base.tsc.CLASSES.Skill or __TS__Class2("Skill")
Slot = base.tsc.CLASSES.Slot or __TS__Class2("Slot")
DamageInstance = base.tsc.CLASSES.DamageInstance or __TS__Class2("DamageInstance")
TriggerEvent = base.tsc.CLASSES.TriggerEvent or __TS__Class2("TriggerEvent")
HealInstance = base.tsc.CLASSES.HealInstance or __TS__Class2("HealInstance")
Buff = base.tsc.CLASSES.Buff or __TS__Class2("Buff")
Unit = base.tsc.CLASSES.Unit or __TS__Class2("Unit")
Mover = base.tsc.CLASSES.Mover or __TS__Class2("Mover")
Point = base.tsc.CLASSES.Point or __TS__Class2("Point")
EffectParam = base.tsc.CLASSES.EffectParam or __TS__Class2("EffectParam")
UnitTable = base.tsc.CLASSES.UnitTable or __TS__Class2("UnitTable")
Target = base.tsc.CLASSES.Target or __TS__Class2("Target")
ScreenPos = base.tsc.CLASSES.ScreenPos or __TS__Class2("ScreenPos")
Region = base.tsc.CLASSES.Region or __TS__Class2("Region")
Item = base.tsc.CLASSES.Item or __TS__Class2("Item")
TriggerParamTable = base.tsc.CLASSES.TriggerParamTable or __TS__Class2("TriggerParamTable")
EffectParamShared = base.tsc.CLASSES.EffectParamShared or __TS__Class2("EffectParamShared")
Snapshot = base.tsc.CLASSES.Snapshot or __TS__Class2("Snapshot")
Timer = base.tsc.CLASSES.Timer or __TS__Class2("Timer")
Team = base.tsc.CLASSES.Team or __TS__Class2("Team")
Actor = base.tsc.CLASSES.Actor or __TS__Class2("Actor")
Coroutine = base.tsc.CLASSES.Coroutine or __TS__Class2("Coroutine")
IEventNotify = base.tsc.CLASSES.IEventNotify or __TS__Class2("IEventNotify")
Present = base.tsc.CLASSES.Present or __TS__Class2("Present")
Array = base.tsc.CLASSES.Array or __TS__Class2("Array")
turn_test_fkoa = turn_test_fkoa or ({})
do
    local function _TRIG_测试_FUNC(当前触发器, e)
        if true then
            if e.key_keyboard == "N" then
                base.push_turn()
            else
            end
        end
    end
    turn_test_fkoa.测试 = base.trigger_new(
        _TRIG_测试_FUNC,
        {},
        true,
        nil,
        true
    )
    local function _TRIG_游戏开始_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa:func_初始化玩家队伍(
                base.player(1),
                base.get_default_unit("测试_1", "大地图_英雄", "测试")
            )
            base.game.load_scene("default")
        end
    end
    turn_test_fkoa.游戏开始 = base.trigger_new(
        _TRIG_游戏开始_FUNC,
        {},
        false,
        nil,
        true
    )
    turn_test_fkoa.func_切换地图黑屏 = function(____, 持续时间, 跳转玩家)
        base.send_custom_event(__TS__New(
            turn_test_fkoa.event_切换地图黑屏,
            {},
            base.game,
            持续时间,
            跳转玩家
        ))
    end
    turn_test_fkoa.func_ui更新行动队列 = function()
        local 单位id数组 = __TS__New(
            Array,
            {__TS__Keyword("number")}
        )
        local 行动类型数组 = __TS__New(
            Array,
            {__TS__Keyword("number")}
        )
        local id
        local 大招
        if turn_test_fkoa.g_bol_大招回合 == true then
            if turn_test_fkoa.v_插入大招array ~= nil then
                for 索引, 匹配的大招 in base.ArrayIterator(turn_test_fkoa.v_插入大招array) do
                    id = 匹配的大招.单位:get_id()
                    单位id数组[#单位id数组 + 1] = id
                    行动类型数组[#行动类型数组 + 1] = 2
                end
            else
                log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
            end
        else
        end
        __TS__ArrayForEachEx(
            turn_test_fkoa.g_unit_回合制队列,
            function(____, 元素, 引用)
                id = 元素:get_id()
                单位id数组[#单位id数组 + 1] = id
                行动类型数组[#行动类型数组 + 1] = 1
                if 引用 == 0 and turn_test_fkoa.g_bol_大招回合 == false then
                    if turn_test_fkoa.v_插入大招array ~= nil then
                        for 索引, 匹配的大招 in base.ArrayIterator(turn_test_fkoa.v_插入大招array) do
                            id = 匹配的大招.单位:get_id()
                            单位id数组[#单位id数组 + 1] = id
                            行动类型数组[#行动类型数组 + 1] = 2
                        end
                    else
                        log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
                    end
                else
                end
            end
        )
        base.send_custom_event(__TS__New(
            turn_test_fkoa.event_队列更新_new,
            {},
            base.game,
            单位id数组,
            行动类型数组
        ))
    end
    turn_test_fkoa.func_战斗单位移动位置_走 = function(____, 单位, 点)
        单位:walk(点)
    end
    turn_test_fkoa.func_战斗单位移动位置_瞬移 = function(____, 单位, 点)
        单位:blink_ex(点)
        单位:walk(点)
        if 单位:get_team_id() == turn_test_fkoa.g_玩家:get_team_id() then
            单位:set_facing(turn_test_fkoa.g_战斗_面向角度_玩家)
        else
            单位:set_facing(turn_test_fkoa.g_战斗_面向角度_敌人)
        end
    end
    turn_test_fkoa.g_bol_大招回合 = false
    turn_test_fkoa.g_contant_敌对玩家 = base.player(2)
    turn_test_fkoa.g_玩家 = base.player(1)
    turn_test_fkoa.g_初始位置 = __TS__New(
        Map,
        {
            __TS__TypeReference(Unit, {}),
            __TS__TypeReference(Point, {})
        },
        __TS__New(Array, {{kind = "TupleType"}})
    )
    turn_test_fkoa.g_actor_候选表现 = __TS__New(
        Array,
        {__TS__TypeReference(Actor, {})}
    )
    turn_test_fkoa.g_actor_选中 = base.create_actor_at(
        "$$turn_test_fkoa.actor.选中.root",
        base.scene_point(1, 1, 0, "default"),
        true
    )
    turn_test_fkoa.g_actor_行动 = base.create_actor_at(
        "$$turn_test_fkoa.actor.行动.root",
        base.scene_point(1, 1, 0, "default"),
        true
    )
    turn_test_fkoa.g_unit_回合制队列 = __TS__New(
        Array,
        {__TS__TypeReference(Unit, {})}
    )
    turn_test_fkoa.g_战斗_面向角度_敌人 = 210
    turn_test_fkoa.g_战斗_面向角度_玩家 = 20
    turn_test_fkoa.event_队列更新 = __TS__Class()
    local event_队列更新 = turn_test_fkoa.event_队列更新
    event_队列更新.name = "event_队列更新"
    __TS__ClassExtends(
        event_队列更新,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_队列更新.prototype.____constructor(self, obj, 单位队列)
        __TS__SuperTypeArgumentsFuncWrapper(event_队列更新, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位队列 = 单位队列
        self.event_name = "event_队列更新"
        self.autoForward = true
    end
    turn_test_fkoa.event_队列更新_new = __TS__Class()
    local event_队列更新_new = turn_test_fkoa.event_队列更新_new
    event_队列更新_new.name = "event_队列更新_new"
    __TS__ClassExtends(
        event_队列更新_new,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_队列更新_new.prototype.____constructor(self, obj, 单位队列, 行动类型队列)
        __TS__SuperTypeArgumentsFuncWrapper(event_队列更新_new, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位队列 = 单位队列
        self.行动类型队列 = 行动类型队列
        self.event_name = "event_队列更新_new"
        self.autoForward = true
    end
    turn_test_fkoa.event_队列更新_插入大招 = __TS__Class()
    local event_队列更新_插入大招 = turn_test_fkoa.event_队列更新_插入大招
    event_队列更新_插入大招.name = "event_队列更新_插入大招"
    __TS__ClassExtends(
        event_队列更新_插入大招,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_队列更新_插入大招.prototype.____constructor(self, obj, 单位队列)
        __TS__SuperTypeArgumentsFuncWrapper(event_队列更新_插入大招, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位队列 = 单位队列
        self.event_name = "event_队列更新_插入大招"
        self.autoForward = true
    end
    turn_test_fkoa.event_单位行动完成 = __TS__Class()
    local event_单位行动完成 = turn_test_fkoa.event_单位行动完成
    event_单位行动完成.name = "event_单位行动完成"
    __TS__ClassExtends(
        event_单位行动完成,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_单位行动完成.prototype.____constructor(self, obj, 单位, 推进)
        __TS__SuperTypeArgumentsFuncWrapper(event_单位行动完成, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位 = 单位
        self.推进 = 推进
        self.event_name = "event_单位行动完成"
        self.autoForward = false
    end
    turn_test_fkoa.event_技能释放完成 = __TS__Class()
    local event_技能释放完成 = turn_test_fkoa.event_技能释放完成
    event_技能释放完成.name = "event_技能释放完成"
    __TS__ClassExtends(
        event_技能释放完成,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_技能释放完成.prototype.____constructor(self, obj, 技能)
        __TS__SuperTypeArgumentsFuncWrapper(event_技能释放完成, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.技能 = 技能
        self.event_name = "event_技能释放完成"
        self.autoForward = false
    end
    turn_test_fkoa.event_切换地图黑屏 = __TS__Class()
    local event_切换地图黑屏 = turn_test_fkoa.event_切换地图黑屏
    event_切换地图黑屏.name = "event_切换地图黑屏"
    __TS__ClassExtends(
        event_切换地图黑屏,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_切换地图黑屏.prototype.____constructor(self, obj, 转场时间, 跳转玩家)
        __TS__SuperTypeArgumentsFuncWrapper(event_切换地图黑屏, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.转场时间 = 转场时间
        self.跳转玩家 = 跳转玩家
        self.event_name = "event_切换地图黑屏"
        self.autoForward = true
    end
    turn_test_fkoa.event_回合制战斗_进入 = __TS__Class()
    local event_回合制战斗_进入 = turn_test_fkoa.event_回合制战斗_进入
    event_回合制战斗_进入.name = "event_回合制战斗_进入"
    __TS__ClassExtends(
        event_回合制战斗_进入,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_回合制战斗_进入.prototype.____constructor(self, obj, player)
        __TS__SuperTypeArgumentsFuncWrapper(event_回合制战斗_进入, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.player = player
        self.event_name = "event_回合制战斗_进入"
        self.autoForward = true
    end
    turn_test_fkoa.event_回合制战斗_退出 = __TS__Class()
    local event_回合制战斗_退出 = turn_test_fkoa.event_回合制战斗_退出
    event_回合制战斗_退出.name = "event_回合制战斗_退出"
    __TS__ClassExtends(
        event_回合制战斗_退出,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_回合制战斗_退出.prototype.____constructor(self, obj, player)
        __TS__SuperTypeArgumentsFuncWrapper(event_回合制战斗_退出, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.player = player
        self.event_name = "event_回合制战斗_退出"
        self.autoForward = true
    end
    turn_test_fkoa.g_bol_脚本施法 = false
    turn_test_fkoa.g_bol_触发拦截施法结束 = false
    turn_test_fkoa.func_归位 = function(____, 单位)
        local 新变量
        turn_test_fkoa:func_战斗单位移动位置_走(
            单位,
            turn_test_fkoa.g_初始位置:get(单位)
        )
    end
    turn_test_fkoa.func_敌方行为 = function(____, 战斗对象, 单位)
        local 所有技能 = base.unit_all_skill(单位)
        local 己方单位 = 战斗对象:get_随机玩家单位()
        local 随机到的技能 = 所有技能[base.math.random_int(0, #所有技能 - 1) + 1]
        local 技能id = 随机到的技能:get_name()
        turn_test_fkoa.g_玩家:set_hero(base.get_default_unit("初始地图_9", "马甲单位"))
        if 单位:has_buff("$$default_units_ts.buff.眩晕.root") then
            log.info("眩晕了")
            base.timer_wait(
                0.5,
                function()
                    base.send_custom_event(__TS__New(
                        turn_test_fkoa.event_单位行动完成,
                        {},
                        base.game,
                        单位,
                        true
                    ))
                end
            )
        else
            单位:cast_on_unit(随机到的技能, 己方单位)
        end
    end
    turn_test_fkoa.func_己方行为 = function(____, 单位)
        turn_test_fkoa.g_玩家:set_hero(单位)
    end
    turn_test_fkoa.func_指定单位行动 = function(____, 行动单位)
        turn_test_fkoa.g_unit_当前行动单位 = 行动单位
        turn_test_fkoa.g_actor_行动:destroy(true)
        turn_test_fkoa.g_actor_行动 = base.create_actor_at(
            "$$turn_test_fkoa.actor.行动.root",
            turn_test_fkoa.g_unit_当前行动单位:get_scene_point(),
            true
        )
        turn_test_fkoa.g_actor_行动:play()
        if turn_test_fkoa.v_当前战斗 == nil then
            return nil
        else
        end
        if 行动单位:get_team_id() == turn_test_fkoa.g_玩家:get_team_id() then
            turn_test_fkoa:func_己方行为(行动单位)
        else
            turn_test_fkoa:func_敌方行为(turn_test_fkoa.v_当前战斗, 行动单位)
        end
    end
    local function _TRIG_trg_近战技能_移动_FUNC(当前触发器, e)
        local 施法距离 = 100
        local 单位距离 = 0
        if turn_test_fkoa.g_bol_脚本施法 == false then
            if e.cast:get("是近战技能") == 1 and e.target_unit_cast ~= nil and e.target_unit_cast:get_scene_point():distance(e.unit:get_scene_point()) >= 施法距离 then
                turn_test_fkoa.g_bol_触发拦截施法结束 = true
                e.cast:bail()
                e.unit:walk(e.target_unit_cast:get_scene_point():polar_to_ex(
                    e.target_unit_cast:get_scene_point():angle(e.unit:get_scene_point()),
                    施法距离
                ))
                单位距离 = e.unit:get_scene_point():distance(e.target_unit_cast:get_scene_point())
                base.timer_wait(
                    (单位距离 - 施法距离) / e.unit:get_ex("移动速度", 0),
                    function()
                        turn_test_fkoa.g_bol_触发拦截施法结束 = false
                        turn_test_fkoa.g_bol_脚本施法 = true
                        e.unit:cast_on_unit(e.skill_id, e.target_unit_cast)
                        log.info("触发发动技能")
                        turn_test_fkoa.g_bol_脚本施法 = false
                    end
                )
            else
            end
        end
    end
    turn_test_fkoa.trg_近战技能_移动 = base.trigger_new(
        _TRIG_trg_近战技能_移动_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_单位行动时_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa:func_指定单位行动(e.u)
        end
    end
    turn_test_fkoa.单位行动时 = base.trigger_new(
        _TRIG_单位行动时_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_己方施法_FUNC(当前触发器, e)
        local cache = base.eff.cache_ts(
            __TS__TypeReference(_OBJ__spell_Spell, {}),
            e.skill_id
        )
        local 大招
        if e.unit:get_string("STRING_回合制战斗单位") == "1" and e.unit:get_team_id() == turn_test_fkoa.g_玩家:get_team_id() and turn_test_fkoa.g_bol_触发拦截施法结束 == false then
            __TS__ArrayFilter(
                cache.Categories,
                function(____, 元素, 引用)
                    if 元素 == base.force_as(
                        __TS__TypeReference(_OBJ__AbilCategory, {}),
                        "大招"
                    ) then
                        大招 = turn_test_fkoa:get_单位大招(e.unit)
                        大招:清空能量()
                        if turn_test_fkoa.g_bol_大招回合 == true then
                            turn_test_fkoa:func_大招_插入回合结束()
                        else
                        end
                    else
                    end
                    return true
                end
            )
            if e.skill_id == "$$turn_test_fkoa.spell.立即行动.root" then
            else
                base.send_custom_event(__TS__New(
                    turn_test_fkoa.event_单位行动完成,
                    {},
                    base.game,
                    e.unit,
                    true
                ))
            end
        end
    end
    turn_test_fkoa.己方施法 = base.trigger_new(
        _TRIG_己方施法_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_敌方施法_FUNC(当前触发器, e)
        if e.unit:get_team_id() ~= turn_test_fkoa.g_玩家:get_team_id() and e.unit:get_string("STRING_回合制战斗单位") == "1" and turn_test_fkoa.g_bol_触发拦截施法结束 == false then
            log.info("施法后摇时", e.unit)
            base.send_custom_event(__TS__New(
                turn_test_fkoa.event_单位行动完成,
                {},
                base.game,
                e.unit,
                true
            ))
        end
    end
    turn_test_fkoa.敌方施法 = base.trigger_new(
        _TRIG_敌方施法_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_过_FUNC(当前触发器, e)
        if true then
        end
    end
    turn_test_fkoa.过 = base.trigger_new(
        _TRIG_过_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_队列更新时_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa.g_unit_回合制队列 = e.queue
            turn_test_fkoa:func_ui更新行动队列()
        end
    end
    turn_test_fkoa.队列更新时 = base.trigger_new(
        _TRIG_队列更新时_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_单位行动完成时_FUNC(当前触发器, e)
        local 大招
        if true then
            turn_test_fkoa:func_归位(e.单位)
            log.info("单位行动完成时", e.单位, e.推进)
            if turn_test_fkoa.g_unit_当前行动单位 ~= e.单位 then
                return nil
            else
            end
            大招 = base.object_restore_value(turn_test_fkoa.g_unit_当前行动单位, "大招")
            if 大招 ~= nil then
                log.info("大招+1", e.单位)
                大招:增加能量(1)
            else
                log.info("大招==nil", e.单位)
            end
            if turn_test_fkoa.v_当前战斗 == nil then
                return nil
            else
            end
            if e.推进 == false then
                return nil
            else
            end
            if turn_test_fkoa:func_插入大招检测() == true then
                turn_test_fkoa:func_大招_执行插入回合()
                return nil
            else
            end
            base.push_turn()
        end
    end
    turn_test_fkoa.单位行动完成时 = base.trigger_new(
        _TRIG_单位行动完成时_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_选中单位_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa.g_actor_选中 = base.create_actor_at(
                "$$turn_test_fkoa.actor.选中.root",
                e.unit:get_scene_point(),
                true
            )
            base.actor_attach_to_unit(turn_test_fkoa.g_actor_选中, e.unit, "socket_blood_bar")
            turn_test_fkoa.g_actor_选中:play()
            turn_test_fkoa.g_选中的单位 = e.unit
            log.info(turn_test_fkoa.g_选中的技能id, "选中的技能")
            if turn_test_fkoa.g_选中的技能id ~= nil then
                turn_test_fkoa.g_unit_当前行动单位:cast_on_unit(
                    turn_test_fkoa.g_unit_当前行动单位:find_skill(turn_test_fkoa.g_选中的技能id),
                    turn_test_fkoa.g_选中的单位
                )
            else
            end
        end
    end
    turn_test_fkoa.选中单位 = base.trigger_new(
        _TRIG_选中单位_FUNC,
        {},
        true,
        nil,
        true
    )
    local function _TRIG_取消选中单位_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa.g_actor_选中:destroy(true)
            turn_test_fkoa.g_选中的单位 = nil
        end
    end
    turn_test_fkoa.取消选中单位 = base.trigger_new(
        _TRIG_取消选中单位_FUNC,
        {},
        true,
        nil,
        true
    )
    local function _TRIG_单位死亡时_FUNC(当前触发器, e)
        if e.unit:get_string("STRING_回合制战斗单位") == "1" then
            log.info("单位死亡", e.unit)
            base.delete_turn_unit(e.unit)
            if turn_test_fkoa.v_当前战斗 ~= nil then
                turn_test_fkoa.v_当前战斗:func_单位死亡剔除(e.unit)
            else
            end
        end
    end
    turn_test_fkoa.单位死亡时 = base.trigger_new(
        _TRIG_单位死亡时_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_技能被点击_FUNC(当前触发器, e)
        local 己方单位
        local 随机到的技能
        local 单位
        local 遍历到的单位组元素
        local cache = base.eff.cache_ts(
            __TS__TypeReference(_OBJ__spell_Spell, {}),
            e.skill_id
        )
        local 过滤 = cache.AcquireSettings.TargetUnitFilter
        local 目标 = cache.target_type
        local 表现
        if e.unit:get_team_id() == turn_test_fkoa.g_玩家:get_team_id() and true then
            turn_test_fkoa.g_选中的技能id = e.skill_id
            if turn_test_fkoa.g_actor_候选表现 ~= nil then
                for 遍历到的数组索引, 遍历到的数组元素 in base.ArrayIterator(turn_test_fkoa.g_actor_候选表现) do
                    遍历到的数组元素:destroy(true)
                end
            else
                log.warn("不能遍历：turn_test_fkoa.g_actor_候选表现")
            end
            turn_test_fkoa.g_actor_候选表现 = __TS__New(
                Array,
                {__TS__TypeReference(Actor, {})}
            )
            if 过滤.敌方 == "Excluded" then
                log.warn("不能生成语句: 未找到元素：[TRG_ENV: server, packageName: turn_test_fkoa, id: Variable:单位组:1160135217]")
            else
                log.warn("不能生成语句: 未找到元素：[TRG_ENV: server, packageName: turn_test_fkoa, id: Variable:单位组:1160135217]")
            end
            if turn_test_fkoa.g_选中的单位 == nil then
                log.info(
                    "打断技能",
                    e.cast,
                    base.force_as(
                        __TS__Keyword("string"),
                        目标
                    )
                )
                e.cast:bail()
            else
                e.unit:cast_on_unit(
                    e.unit:find_skill(e.skill_id),
                    turn_test_fkoa.g_选中的单位
                )
            end
        end
    end
    turn_test_fkoa.技能被点击 = base.trigger_new(
        _TRIG_技能被点击_FUNC,
        {},
        true,
        nil,
        true
    )
    turn_test_fkoa.回合制战斗 = __TS__Class()
    local 回合制战斗 = turn_test_fkoa.回合制战斗
    回合制战斗.name = "回合制战斗"
    function 回合制战斗.prototype.____constructor(self)
        self.玩家 = nil
        self.group_敌人 = base.create_unit_group(nil)
        self.group_玩家 = base.create_unit_group(nil)
        self.玩家场景 = "测试"
        self.转场时间 = 1.5
        self.行动计时器 = base.timer_loop(
            0.2,
            function()
                local 遍历到的单位
                local 新变量
                local 新变量_1
                local temp = 1
                self.group_敌人:forEachEx(function(____, 遍历到的单位)
                    if self.array_战斗点_敌人[temp + 1]:distance(遍历到的单位:get_scene_point()) <= 15 then
                        遍历到的单位:set_facing(turn_test_fkoa.g_战斗_面向角度_敌人)
                    else
                    end
                    temp = temp + 1
                end)
                temp = 1
                self.group_玩家:forEachEx(function(____, 遍历到的单位)
                    if self.array_战斗点_玩家[temp + 1]:distance(遍历到的单位:get_scene_point()) <= 15 then
                        遍历到的单位:set_facing(turn_test_fkoa.g_战斗_面向角度_玩家)
                    else
                    end
                    temp = temp + 1
                end)
            end
        )
        self.func_开始 = function()
            local 新变量
            local 玩家队伍 = turn_test_fkoa:func_获取指定玩家队伍(self.玩家)
            base.send_custom_event(__TS__New(turn_test_fkoa.event_回合制战斗_进入, {}, base.game, self.玩家))
            log.info("回合制战斗-开始", self.玩家, 玩家队伍)
            玩家队伍.战斗单位:forEachEx(function(____, 遍历到的单位)
                self.group_玩家:add(遍历到的单位)
            end)
            self:func_战斗点刷新()
            玩家队伍.战斗单位:forEachEx(function(____, 遍历到的单位)
                遍历到的单位:find_buff("$$turn_test_fkoa.buff.回合制_战斗隐藏.root"):remove()
                遍历到的单位:jump_scene("default")
                遍历到的单位:blink_ex(self.玩家创建点)
            end)
            turn_test_fkoa:func_切换地图黑屏(self.转场时间, self.玩家)
            base.player_set_camera(self.玩家, "$$turn_test_fkoa.camera_property.进入战斗镜头.root", self.转场时间 / 2)
            base.timer_wait(
                self.转场时间 / 2,
                function()
                    self:func_战斗位置刷新()
                    self:func_玩家跳转战斗场景()
                end
            )
            base.timer_wait(
                self.转场时间 + 1,
                function()
                    self:func_回合制启动()
                end
            )
        end
        self.func_结束 = function(____, 胜利)
            local 玩家队伍 = turn_test_fkoa:func_获取指定玩家队伍(self.玩家)
            local 大地图单位 = 玩家队伍.大地图单位
            turn_test_fkoa:func_切换地图黑屏(self.转场时间, self.玩家)
            base.timer_wait(
                self.转场时间 / 2,
                function()
                    base.exit_turn_based_mode()
                    turn_test_fkoa.v_当前战斗 = nil
                    if 胜利 == true then
                        if self.遇雷单位 ~= nil then
                            self.遇雷单位:kill(大地图单位)
                        else
                        end
                    else
                    end
                    玩家队伍.战斗单位:forEachEx(function(____, 遍历到的单位)
                        base.unit_add_buff(遍历到的单位, "$$turn_test_fkoa.buff.回合制_战斗隐藏.root", 1)
                    end)
                    大地图单位:find_buff("$$turn_test_fkoa.buff.回合制_战斗隐藏.root"):remove()
                    self.玩家:set_hero(大地图单位)
                    base.player_jump_scene(self.玩家, self.玩家场景, true)
                    大地图单位:blink_ex(self.玩家大地图位置)
                    base.player_set_camera(self.玩家, "$$.camera_property.camerapro.root", 0)
                    self.玩家:camera_focus(大地图单位)
                    base.send_custom_event(__TS__New(turn_test_fkoa.event_回合制战斗_退出, {}, base.game, self.玩家))
                    self:func_结束销毁()
                end
            )
        end
        self.func_创建敌人 = function(____, 新参数)
            local unit = base.player_create_unit_ai(
                turn_test_fkoa.g_contant_敌对玩家,
                新参数,
                self.敌人创建点,
                180,
                false
            )
            unit:set_string("STRING_回合制战斗单位", "1")
            self.group_敌人:add(unit)
        end
        self.func_战斗点刷新 = function()
            local angle = -75
            local distance = 200
            local value = 0
            do
                local 索引 = 1
                while 索引 <= self.group_敌人.size do
                    value = (索引 - (self.group_敌人.size + 1) / 2) * distance
                    self.array_战斗点_敌人[索引 + 1] = self.敌人点:polar_to_ex(angle + 180, value)
                    索引 = 索引 + 1
                end
            end
            do
                local 索引 = 1
                while 索引 <= self.group_玩家.size do
                    value = (索引 - (self.group_玩家.size + 1) / 2) * distance
                    self.array_战斗点_玩家[索引 + 1] = self.玩家点:polar_to_ex(angle, value)
                    索引 = 索引 + 1
                end
            end
        end
        self.func_战斗位置刷新 = function()
            local temp = 0
            self.group_敌人:forEachEx(function(____, 遍历到的单位)
                temp = temp + 1
                turn_test_fkoa:func_战斗单位移动位置_走(遍历到的单位, self.array_战斗点_敌人[temp + 1])
                turn_test_fkoa.g_初始位置:set(遍历到的单位, self.array_战斗点_敌人[temp + 1])
            end)
            temp = 0
            self.group_玩家:forEachEx(function(____, 遍历到的单位)
                temp = temp + 1
                turn_test_fkoa:func_战斗单位移动位置_走(遍历到的单位, self.array_战斗点_玩家[temp + 1])
                turn_test_fkoa.g_初始位置:set(遍历到的单位, self.array_战斗点_玩家[temp + 1])
            end)
        end
        self.func_玩家跳转战斗场景 = function()
            local 玩家队伍 = turn_test_fkoa:func_获取指定玩家队伍(self.玩家)
            local 大地图单位 = 玩家队伍.大地图单位
            self.玩家大地图位置 = 大地图单位:get_scene_point()
            self.玩家场景 = 大地图单位:get_scene_name()
            base.player_jump_scene(self.玩家, "default", true)
            self.玩家:unlock_camera()
            base.player_set_camera(self.玩家, "$$turn_test_fkoa.camera_property.战斗镜头_初始.root", 0)
            base.player_set_camera(self.玩家, "$$turn_test_fkoa.camera_property.战斗镜头.root", self.转场时间 * 0.4)
            base.unit_add_buff(大地图单位, "$$turn_test_fkoa.buff.回合制_战斗隐藏.root", 1)
        end
        self.func_回合制启动 = function()
            local 新变量
            local group = base.create_unit_group(nil)
            self.group_玩家:forEachEx(function(____, 遍历到的单位)
                group:add(遍历到的单位)
            end)
            self.group_敌人:forEachEx(function(____, 遍历到的单位)
                group:add(遍历到的单位)
            end)
            group:forEachEx(function(____, 遍历到的单位)
                local 所有技能 = base.unit_all_skill(遍历到的单位)
                local 大招
                大招 = turn_test_fkoa:get_单位大招(遍历到的单位)
                if 大招 == nil then
                    if 所有技能 ~= nil then
                        for 遍历到的数组索引, 遍历到的数组元素 in base.ArrayIterator(所有技能) do
                            __TS__ArrayFilter(
                                遍历到的数组元素.cache.Categories,
                                function(____, 元素, 引用)
                                    if 元素 == base.force_as(
                                        __TS__TypeReference(_OBJ__AbilCategory, {}),
                                        "大招"
                                    ) then
                                        log.info("大招", 引用)
                                        大招 = __TS__ObjectAssign(
                                            __TS__New(turn_test_fkoa.大招, {}),
                                            {
                                                需要能量 = 1,
                                                当前能量 = 1,
                                                大招技能id = 遍历到的数组元素:get_name(),
                                                单位 = 遍历到的单位
                                            }
                                        )
                                        if 大招.当前能量 < 大招.需要能量 then
                                            遍历到的单位:find_skill(遍历到的数组元素:get_name()):disable()
                                        else
                                        end
                                        base.object_store_value(遍历到的单位, "大招", 大招)
                                    else
                                    end
                                    return true
                                end
                            )
                        end
                    else
                        log.warn("不能遍历：所有技能")
                    end
                else
                end
            end)
            base.enter_turn_based_mode(group)
        end
        self.get_随机玩家单位 = function()
            return self.group_玩家:random()
        end
        self.func_战斗结束检测 = function()
            if self.group_敌人.size == 0 then
                self:func_结束(true)
            else
            end
            if self.group_玩家.size == 0 then
                self:func_结束(false)
            else
            end
        end
        self.func_单位死亡剔除 = function(____, unit)
            if base.unit_group_contains(self.group_敌人, unit) then
                base.unit_group_remove_item(self.group_敌人, unit)
                self:func_战斗点刷新()
                self:func_战斗位置刷新()
                self:func_战斗结束检测()
                return nil
            else
            end
            if base.unit_group_contains(self.group_玩家, unit) then
                base.unit_group_remove_item(self.group_玩家, unit)
                self:func_战斗点刷新()
                self:func_战斗位置刷新()
                self:func_战斗结束检测()
                return nil
            else
            end
        end
        self.func_指定单位归位 = function(____, unit)
        end
        self.func_结束销毁 = function()
            if self.行动计时器 ~= nil then
                self.行动计时器:remove()
                self.行动计时器 = nil
            else
            end
        end
        self.array_战斗点_敌人 = __TS__New(
            Array,
            {__TS__Keyword("any")}
        )
        self.array_战斗点_玩家 = __TS__New(
            Array,
            {__TS__Keyword("any")}
        )
    end
    local function _TRIG_trg_进入战斗_FUNC(当前触发器, e)
        local 玩家
        if e.damage_source:get_string("STRING_大地图单位") == "1" and e.damage_target:get_string("STRING_大地图单位") == "1" then
            if turn_test_fkoa:func_获取指定玩家队伍(e.damage_source:get_owner()) ~= nil then
                玩家 = e.damage_source:get_owner()
                turn_test_fkoa:func_进入战斗(玩家, e.damage_target)
            else
                if turn_test_fkoa:func_获取指定玩家队伍(e.damage_target:get_owner()) ~= nil then
                    玩家 = e.damage_target:get_owner()
                    turn_test_fkoa:func_进入战斗(玩家, e.damage_source)
                else
                end
            end
            base.unit_add_buff(e.damage_target, "$$turn_test_fkoa.buff.回合制_大地图被攻击晕眩.root", 1)
        end
    end
    turn_test_fkoa.trg_进入战斗 = base.trigger_new(
        _TRIG_trg_进入战斗_FUNC,
        {},
        false,
        nil,
        true
    )
    turn_test_fkoa.func_进入战斗 = function(____, player, enemy)
        local 敌人配置
        local 单位表
        if turn_test_fkoa.v_当前战斗 ~= nil then
            log.warn("上一场战斗未完成")
            return nil
        else
        end
        turn_test_fkoa.v_当前战斗 = __TS__ObjectAssign(
            __TS__New(turn_test_fkoa.回合制战斗, {}),
            {
                玩家 = player,
                遇雷单位 = enemy,
                玩家点 = base.get_scene_point("default", "玩家战斗位置", _G.present),
                敌人点 = base.get_scene_point("default", "敌人战斗位置", _G.present),
                敌人创建点 = base.get_scene_point("default", "敌人进场位置", _G.present),
                玩家创建点 = base.get_scene_point("default", "玩家进场位置", _G.present)
            }
        )
        敌人配置 = turn_test_fkoa:func_获取敌人队伍(enemy)
        if 敌人配置 == nil then
            log.error("警告，获取敌人配置错误", enemy)
            return nil
        else
        end
        单位表 = 敌人配置.unit_list
        if 单位表 ~= nil then
            for 索引, 单位ID in base.ArrayIterator(单位表) do
                turn_test_fkoa.v_当前战斗:func_创建敌人(单位ID)
            end
        else
            log.warn("不能遍历：单位表")
        end
        turn_test_fkoa.v_当前战斗:func_开始()
    end
    turn_test_fkoa.func_获取敌人队伍 = function(____, 大世界敌人)
        repeat
            local ____switch170 = 大世界敌人:get_name()
            local ____cond170 = ____switch170 == "$$turn_test_fkoa.unit.不死鸟.root"
            if ____cond170 then
                do
                    return base.eff.cache("$$turn_test_fkoa.turn_demo.凤凰.root")
                end
            end
            ____cond170 = ____cond170 or ____switch170 == "$$turn_test_fkoa.unit.水元素.root"
            if ____cond170 then
                do
                    return base.eff.cache("$$turn_test_fkoa.turn_demo.水元素.root")
                end
            end
            ____cond170 = ____cond170 or ____switch170 == "$$turn_test_fkoa.unit.爬虫.root"
            if ____cond170 then
                do
                    if base.math.random_int(0, 10) <= 5 then
                        return base.eff.cache("$$turn_test_fkoa.turn_demo.蜘蛛.root")
                    else
                        return base.eff.cache("$$turn_test_fkoa.turn_demo.蜘蛛_1.root")
                    end
                end
            end
            do
                do
                    break
                end
            end
        until true
    end
    turn_test_fkoa.event_玩家_添加战斗单位 = __TS__Class()
    local event_玩家_添加战斗单位 = turn_test_fkoa.event_玩家_添加战斗单位
    event_玩家_添加战斗单位.name = "event_玩家_添加战斗单位"
    __TS__ClassExtends(
        event_玩家_添加战斗单位,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_玩家_添加战斗单位.prototype.____constructor(self, obj, 玩家, 单位)
        __TS__SuperTypeArgumentsFuncWrapper(event_玩家_添加战斗单位, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.玩家 = 玩家
        self.单位 = 单位
        self.event_name = "event_玩家_添加战斗单位"
        self.autoForward = false
    end
    turn_test_fkoa.玩家队伍 = __TS__Class()
    local 玩家队伍 = turn_test_fkoa.玩家队伍
    玩家队伍.name = "玩家队伍"
    function 玩家队伍.prototype.____constructor(self)
        self.func_添加战斗单位 = function(____, ID)
            local unit
            unit = base.player_create_unit_ai(
                self.玩家,
                ID,
                self.大地图单位:get_scene_point(),
                0,
                false
            )
            base.unit_add_buff(unit, "$$turn_test_fkoa.buff.回合制_战斗隐藏.root", 1)
            unit:set_string("STRING_回合制战斗单位", "1")
            self.战斗单位:add(unit)
            base.send_custom_event(__TS__New(
                turn_test_fkoa.event_玩家_添加战斗单位,
                {},
                base.game,
                self.玩家,
                unit
            ))
        end
        self.战斗单位 = base.create_unit_group(nil)
    end
    turn_test_fkoa.array_玩家队伍 = __TS__New(
        Array,
        {__TS__TypeReference(turn_test_fkoa.玩家队伍, {})}
    )
    turn_test_fkoa.func_初始化玩家队伍 = function(____, 玩家, 大地图单位)
        local 队伍 = __TS__ObjectAssign(
            __TS__New(turn_test_fkoa.玩家队伍, {}),
            {大地图单位 = 大地图单位, 战斗单位 = nil, 玩家 = 玩家}
        )
        turn_test_fkoa.array_玩家队伍[玩家:get_slot_id() + 1] = 队伍
        队伍:func_添加战斗单位("$$default_units_ts.unit.星火战士.root")
        队伍:func_添加战斗单位("$$default_units_ts.unit.6、远程普攻示例英雄.root")
        队伍:func_添加战斗单位("$$default_units_ts.unit.sce2号.root")
        return 队伍
    end
    turn_test_fkoa.func_获取指定玩家队伍 = function(____, player)
        return turn_test_fkoa.array_玩家队伍[player:get_slot_id() + 1]
    end
    turn_test_fkoa.event_大招面板刷新 = __TS__Class()
    local event_大招面板刷新 = turn_test_fkoa.event_大招面板刷新
    event_大招面板刷新.name = "event_大招面板刷新"
    __TS__ClassExtends(
        event_大招面板刷新,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_大招面板刷新.prototype.____constructor(self, obj, 单位队列, 技能link, 能量, 能量上限)
        __TS__SuperTypeArgumentsFuncWrapper(event_大招面板刷新, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位队列 = 单位队列
        self.技能link = 技能link
        self.能量 = 能量
        self.能量上限 = 能量上限
        self.event_name = "event_大招面板刷新"
        self.autoForward = true
    end
    turn_test_fkoa.event_大招能量刷新 = __TS__Class()
    local event_大招能量刷新 = turn_test_fkoa.event_大招能量刷新
    event_大招能量刷新.name = "event_大招能量刷新"
    __TS__ClassExtends(
        event_大招能量刷新,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_大招能量刷新.prototype.____constructor(self, obj, 单位, 能量)
        __TS__SuperTypeArgumentsFuncWrapper(event_大招能量刷新, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位 = 单位
        self.能量 = 能量
        self.event_name = "event_大招能量刷新"
        self.autoForward = true
    end
    turn_test_fkoa.v_插入大招array = __TS__New(
        Array,
        {__TS__TypeReference(turn_test_fkoa.大招, {})}
    )
    turn_test_fkoa.func_大招面板刷新 = function(____, 玩家)
        local 玩家队伍 = turn_test_fkoa:func_获取指定玩家队伍(玩家)
        local 单位ID = __TS__New(
            Array,
            {__TS__Keyword("number")}
        )
        local 技能link = __TS__New(
            Array,
            {__TS__TypeReference(IdPreset, {{kind = "LiteralType", literal = "spell_id"}})}
        )
        local 能量 = __TS__New(
            Array,
            {__TS__Keyword("number")}
        )
        local 能量上限 = __TS__New(
            Array,
            {__TS__Keyword("number")}
        )
        玩家队伍.战斗单位:forEachEx(function(____, 遍历到的单位, 大招)
            大招 = base.object_restore_value(遍历到的单位, "大招")
            if 大招 ~= nil then
                单位ID[#单位ID + 1] = 遍历到的单位:get_id()
                技能link[#技能link + 1] = 大招.大招技能id
                能量[#能量 + 1] = 大招.当前能量
                能量上限[#能量上限 + 1] = 大招.需要能量
                log.info(
                    "大招",
                    遍历到的单位:get_id(),
                    大招.大招技能id,
                    大招.当前能量,
                    大招.需要能量
                )
            else
            end
        end)
        base.send_custom_event(__TS__New(
            turn_test_fkoa.event_大招面板刷新,
            {},
            base.game,
            单位ID,
            技能link,
            能量,
            能量上限
        ))
    end
    turn_test_fkoa.func_大招能量刷新 = function(____, 玩家, 单位, 大招)
        log.info(
            "func_大招能量刷新",
            单位:get_id(),
            大招.当前能量
        )
        base.send_custom_event(__TS__New(
            turn_test_fkoa.event_大招能量刷新,
            {},
            base.game,
            单位:get_id(),
            大招.当前能量
        ))
    end
    turn_test_fkoa.func_大招_申请释放 = function(____, 单位编号)
        if turn_test_fkoa.v_当前战斗.group_玩家 ~= nil then
            for ____, 匹配单位 in __TS__Iterator(turn_test_fkoa.v_当前战斗.group_玩家) do
                local 大招
                if 匹配单位:get_id() == 单位编号 then
                    if turn_test_fkoa.g_unit_当前行动单位 == 匹配单位 then
                        return nil
                    else
                    end
                    大招 = turn_test_fkoa:get_单位大招(匹配单位)
                    if 大招 == nil then
                        return nil
                    else
                    end
                    if turn_test_fkoa.v_插入大招array ~= nil then
                        for 遍历到的数组索引, 遍历到的数组元素 in base.ArrayIterator(turn_test_fkoa.v_插入大招array) do
                            if 大招 == 遍历到的数组元素 then
                                return nil
                            else
                            end
                        end
                    else
                        log.warn("不能遍历：turn_test_fkoa.v_插入大招array")
                    end
                    if 大招.当前能量 < 大招.需要能量 then
                        return nil
                    else
                    end
                    local ____turn_test_fkoa_v__63D2_5165_5927_62DBarray_0 = turn_test_fkoa.v_插入大招array
                    ____turn_test_fkoa_v__63D2_5165_5927_62DBarray_0[#____turn_test_fkoa_v__63D2_5165_5927_62DBarray_0 + 1] = 大招
                    log.info("插入大招", 大招, 大招.大招技能id)
                    turn_test_fkoa:func_ui更新行动队列()
                else
                end
            end
        else
            log.warn("不能遍历：turn_test_fkoa.v_当前战斗.group_玩家")
        end
    end
    turn_test_fkoa.get_单位大招 = function(____, 单位)
        return base.object_restore_value(单位, "大招")
    end
    turn_test_fkoa.大招 = __TS__Class()
    local 大招 = turn_test_fkoa.大招
    大招.name = "大招"
    function 大招.prototype.____constructor(self)
        self.需要能量 = nil
        self.当前能量 = nil
        self.大招技能id = nil
        self.单位 = nil
        self.禁用 = false
        self.增加能量 = function(____, 能量)
            if self.当前能量 >= self.需要能量 then
                return nil
            else
            end
            self.当前能量 = self.当前能量 + 能量
            turn_test_fkoa:func_大招能量刷新(
                self.单位:get_owner(),
                self.单位,
                self
            )
            if self.当前能量 >= self.需要能量 then
                self.单位:find_skill(self.大招技能id):enable()
                self.禁用 = false
            else
            end
        end
        self.清空能量 = function()
            self.当前能量 = 0
            self.单位:find_skill(self.大招技能id):disable()
            self.禁用 = true
            turn_test_fkoa:func_大招能量刷新(
                self.单位:get_owner(),
                self.单位,
                self
            )
        end
    end
    turn_test_fkoa.func_插入大招检测 = function()
        if #turn_test_fkoa.v_插入大招array <= 0 then
            return false
        else
            return true
        end
    end
    turn_test_fkoa.func_大招_执行插入回合 = function()
        local 大招 = turn_test_fkoa.v_插入大招array[1]
        local 单位 = 大招.单位
        local 单位数编 = 单位.cache
        __TS__ArraySplice(turn_test_fkoa.g_unit_回合制队列, 0, 1)
        log.info("插入大招回合开始")
        turn_test_fkoa.g_bol_大招回合 = true
        if 单位数编.UnitData.HeroSkill ~= nil then
            for 索引, 匹配技能id in base.ArrayIterator(单位数编.UnitData.HeroSkill) do
                local 技能 = 单位:find_skill(匹配技能id)
                if 技能 ~= nil and 大招.大招技能id ~= 技能:get_name() then
                    技能:disable()
                else
                end
            end
        else
            log.warn("不能遍历：单位数编.UnitData.HeroSkill")
        end
        turn_test_fkoa:func_指定单位行动(单位)
        turn_test_fkoa:func_ui更新行动队列()
    end
    turn_test_fkoa.func_大招_插入回合结束 = function()
        local 大招 = turn_test_fkoa.v_插入大招array[1]
        local 单位 = 大招.单位
        local 单位数编 = 单位.cache
        log.info("func_大招回合结束")
        __TS__ArraySplice(turn_test_fkoa.v_插入大招array, 0, 1)
        turn_test_fkoa.g_bol_大招回合 = false
        if 单位数编.UnitData.HeroSkill ~= nil then
            for 索引, 匹配技能id in base.ArrayIterator(单位数编.UnitData.HeroSkill) do
                local 技能 = 单位:find_skill(匹配技能id)
                if 技能 ~= nil and 大招.大招技能id ~= 技能:get_name() then
                    技能:enable()
                else
                end
            end
        else
            log.warn("不能遍历：单位数编.UnitData.HeroSkill")
        end
        if turn_test_fkoa:func_插入大招检测() == true then
            turn_test_fkoa:func_大招_执行插入回合()
        else
            base.push_turn()
        end
    end
    turn_test_fkoa.func_大招_单位初始化 = function(____, 单位)
        local 所有技能 = base.unit_all_skill(单位)
        local 大招
        大招 = turn_test_fkoa:get_单位大招(单位)
        if 大招 == nil then
            if 所有技能 ~= nil then
                for 遍历到的数组索引, 遍历到的数组元素 in base.ArrayIterator(所有技能) do
                    __TS__ArrayFilter(
                        遍历到的数组元素.cache.Categories,
                        function(____, 元素, 引用)
                            if 元素 == base.force_as(
                                __TS__TypeReference(_OBJ__AbilCategory, {}),
                                "大招"
                            ) then
                                log.info("大招", 引用)
                                大招 = __TS__ObjectAssign(
                                    __TS__New(turn_test_fkoa.大招, {}),
                                    {
                                        需要能量 = 3,
                                        当前能量 = 3,
                                        大招技能id = 遍历到的数组元素:get_name(),
                                        单位 = 单位
                                    }
                                )
                                if 大招.当前能量 < 大招.需要能量 then
                                    单位:find_skill(遍历到的数组元素:get_name()):disable()
                                else
                                end
                                base.object_store_value(单位, "大招", 大招)
                            else
                            end
                            return true
                        end
                    )
                end
            else
                log.warn("不能遍历：所有技能")
            end
        else
        end
    end
    local function _TRIG_trg_申请释放大招_FUNC(当前触发器, e)
        if true then
            log.info("trg_申请释放大招", e.单位id)
            if turn_test_fkoa.v_当前战斗 == nil then
                return nil
            else
            end
            turn_test_fkoa:func_大招_申请释放(e.单位id)
        end
    end
    turn_test_fkoa.trg_申请释放大招 = base.trigger_new(
        _TRIG_trg_申请释放大招_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_trg_大招_退出战斗_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa.v_插入大招array = __TS__New(
                Array,
                {__TS__Keyword("any")}
            )
        end
    end
    turn_test_fkoa.trg_大招_退出战斗 = base.trigger_new(
        _TRIG_trg_大招_退出战斗_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_trg_大招_进入战斗_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa:func_大招面板刷新(e.player)
        end
    end
    turn_test_fkoa.trg_大招_进入战斗 = base.trigger_new(
        _TRIG_trg_大招_进入战斗_FUNC,
        {},
        false,
        nil,
        true
    )
    local function _TRIG_trg_玩家_添加战斗单位_FUNC(当前触发器, e)
        if true then
            turn_test_fkoa:func_大招_单位初始化(e.单位)
        end
    end
    turn_test_fkoa.trg_玩家_添加战斗单位 = base.trigger_new(
        _TRIG_trg_玩家_添加战斗单位_FUNC,
        {},
        false,
        nil,
        true
    )
    turn_test_fkoa.战斗场景 = __TS__Class()
    local 战斗场景 = turn_test_fkoa.战斗场景
    战斗场景.name = "战斗场景"
    function 战斗场景.prototype.____constructor(self)
    end
    turn_test_fkoa.event_申请释放大招 = __TS__Class()
    local event_申请释放大招 = turn_test_fkoa.event_申请释放大招
    event_申请释放大招.name = "event_申请释放大招"
    __TS__ClassExtends(
        event_申请释放大招,
        TriggerEvent,
        function()
            return {}
        end
    )
    function event_申请释放大招.prototype.____constructor(self, obj, 单位id, player_slot_id)
        __TS__SuperTypeArgumentsFuncWrapper(event_申请释放大招, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.单位id = 单位id
        self.player_slot_id = player_slot_id
        self.event_name = "event_申请释放大招"
        self.autoForward = false
    end
    local 过 = __TS__Class()
    过.name = "过"
    __TS__ClassExtends(
        过,
        TriggerEvent,
        function()
            return {}
        end
    )
    function 过.prototype.____constructor(self, obj, player_slot_id)
        __TS__SuperTypeArgumentsFuncWrapper(过, {}, TriggerEvent.prototype.____constructor)(self)
        self.obj = obj
        self.player_slot_id = player_slot_id
        self.event_name = "过"
        self.autoForward = false
    end
    turn_test_fkoa.测试:add_event_common({obj = base.any_player, event_name = "玩家-按键按下"})
    turn_test_fkoa.游戏开始:add_event_common({obj = base.game, event_name = "游戏-开始"})
    turn_test_fkoa.trg_近战技能_移动:add_event_common({obj = base.any_skill, event_name = "技能-施法开始"})
    turn_test_fkoa.单位行动时:add_event_common({obj = base.game, event_name = "回合制模式-单位行动"})
    turn_test_fkoa.己方施法:add_event_common({obj = base.any_skill, event_name = "技能-施法停止"})
    turn_test_fkoa.敌方施法:add_event_common({obj = base.any_skill, event_name = "技能-施法停止"})
    turn_test_fkoa.队列更新时:add_event_common({obj = base.game, event_name = "回合制模式-队列更新"})
    turn_test_fkoa.单位行动完成时:add_event_common({obj = base.game, event_name = "event_单位行动完成"})
    turn_test_fkoa.选中单位:add_event_common({obj = base.any_unit, event_name = "单位-选中"})
    turn_test_fkoa.取消选中单位:add_event_common({obj = base.any_unit, event_name = "单位-取消选中"})
    turn_test_fkoa.单位死亡时:add_event_common({obj = base.any_unit, event_name = "单位-死亡"})
    turn_test_fkoa.技能被点击:add_event_common({obj = base.any_skill, event_name = "技能-施法开始"})
    turn_test_fkoa.trg_进入战斗:add_event_common({obj = base.any_unit, event_name = "造成伤害"})
    turn_test_fkoa.trg_申请释放大招:add_event_common({obj = base.game, event_name = "event_申请释放大招"})
    turn_test_fkoa.trg_大招_退出战斗:add_event_common({obj = base.game, event_name = "event_回合制战斗_退出"})
    turn_test_fkoa.trg_大招_进入战斗:add_event_common({obj = base.game, event_name = "event_回合制战斗_进入"})
    turn_test_fkoa.trg_玩家_添加战斗单位:add_event_common({obj = base.game, event_name = "event_玩家_添加战斗单位"})
end
